home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 6 / Night Owl's Shareware - PDSI-006 - Night Owl Corp (1990).iso / 039a / cdbw.zip / DBMGR.H < prev    next >
Text File  |  1991-05-15  |  13KB  |  313 lines
  1. /*
  2.  *  dbmgr.h
  3.  *
  4.  *  This file contains structures, macros and #defines for
  5.  *  the database layout.
  6.  *
  7.  *  Copyright (C) 1989, 1990, 1991 by Daytris.  All rights reserved.
  8.  */
  9.  
  10. /* DBTALK prototypes */
  11. DWORD FAR PASCAL DbClose( HANDLE);
  12. DWORD FAR PASCAL DbFlush( HANDLE);
  13. DWORD FAR PASCAL DbOpen( HWND, LPSTR, LPSTR, HANDLE *);
  14. DWORD FAR PASCAL DbRecordAdd( HANDLE, LPSTR, HANDLE);
  15. DWORD FAR PASCAL DbRecordDelete( HANDLE, LPSTR);
  16. DWORD FAR PASCAL DbRecordFindByKey( HANDLE, LPSTR, LPSTR, HANDLE);
  17. DWORD FAR PASCAL DbRecordFindFirst( HANDLE, LPSTR, LPSTR);
  18. DWORD FAR PASCAL DbRecordFindLast( HANDLE, LPSTR, LPSTR);
  19. DWORD FAR PASCAL DbRecordFindNext( HANDLE, LPSTR, LPSTR);
  20. DWORD FAR PASCAL DbRecordFindPrev( HANDLE, LPSTR, LPSTR);
  21. DWORD FAR PASCAL DbRecordGetByKey( HANDLE, LPSTR, LPSTR, HANDLE, HANDLE);
  22. DWORD FAR PASCAL DbRecordGetCurrency( HANDLE, LPSTR, HANDLE);
  23. DWORD FAR PASCAL DbRecordGetCurrent( HANDLE, LPSTR, HANDLE);
  24. DWORD FAR PASCAL DbRecordGetFirst( HANDLE, LPSTR, LPSTR, HANDLE);
  25. DWORD FAR PASCAL DbRecordGetLast( HANDLE, LPSTR, LPSTR, HANDLE);
  26. DWORD FAR PASCAL DbRecordGetNext( HANDLE, LPSTR, LPSTR, HANDLE);
  27. DWORD FAR PASCAL DbRecordGetPrev( HANDLE, LPSTR, LPSTR, HANDLE);
  28. DWORD FAR PASCAL DbRecordUpdate( HANDLE, LPSTR, HANDLE);
  29. DWORD FAR PASCAL DbRecordUpdCurrency( HANDLE, LPSTR, HANDLE);
  30. DWORD FAR PASCAL DbSetAdd( HANDLE, LPSTR, LPSTR);
  31. DWORD FAR PASCAL DbSetDelete( HANDLE, LPSTR, LPSTR);
  32. DWORD FAR PASCAL DbSetFindFirst( HANDLE, LPSTR, LPSTR);
  33. DWORD FAR PASCAL DbSetFindLast( HANDLE, LPSTR, LPSTR);
  34. DWORD FAR PASCAL DbSetFindNext( HANDLE, LPSTR, LPSTR);
  35. DWORD FAR PASCAL DbSetFindPrev( HANDLE, LPSTR, LPSTR);
  36. DWORD FAR PASCAL DbSetGetFirst( HANDLE, LPSTR, LPSTR, HANDLE);
  37. DWORD FAR PASCAL DbSetGetLast( HANDLE, LPSTR, LPSTR, HANDLE);
  38. DWORD FAR PASCAL DbSetGetNext( HANDLE, LPSTR, LPSTR, HANDLE);
  39. DWORD FAR PASCAL DbSetGetOwner( HANDLE, LPSTR, LPSTR, HANDLE);
  40. DWORD FAR PASCAL DbSetGetPrev( HANDLE, LPSTR, LPSTR, HANDLE);
  41. DWORD FAR PASCAL XDbRecordAdd( HANDLE, LPSTR, LPVOID, short);
  42. DWORD FAR PASCAL XDbRecordFindByKey( HANDLE, LPSTR, LPSTR, LPVOID, short);
  43. DWORD FAR PASCAL XDbRecordGetByKey( HANDLE, LPSTR, LPSTR, LPVOID, short, LPVOID, short);
  44. DWORD FAR PASCAL XDbRecordGetCurrency( HANDLE, LPSTR, LPVOID, short);
  45. DWORD FAR PASCAL XDbRecordGetCurrent( HANDLE, LPSTR, LPVOID, short);
  46. DWORD FAR PASCAL XDbRecordGetFirst( HANDLE, LPSTR, LPSTR, LPVOID, short);
  47. DWORD FAR PASCAL XDbRecordGetLast( HANDLE, LPSTR, LPSTR, LPVOID, short);
  48. DWORD FAR PASCAL XDbRecordGetNext( HANDLE, LPSTR, LPSTR, LPVOID, short);
  49. DWORD FAR PASCAL XDbRecordGetPrev( HANDLE, LPSTR, LPSTR, LPVOID, short);
  50. DWORD FAR PASCAL XDbRecordUpdate( HANDLE, LPSTR, LPVOID, short);
  51. DWORD FAR PASCAL XDbRecordUpdCurrency( HANDLE, LPSTR, LPVOID, short);
  52. DWORD FAR PASCAL XDbSetGetFirst( HANDLE, LPSTR, LPSTR, LPVOID, short);
  53. DWORD FAR PASCAL XDbSetGetLast( HANDLE, LPSTR, LPSTR, LPVOID, short);
  54. DWORD FAR PASCAL XDbSetGetNext( HANDLE, LPSTR, LPSTR, LPVOID, short);
  55. DWORD FAR PASCAL XDbSetGetOwner( HANDLE, LPSTR, LPSTR, LPVOID, short);
  56. DWORD FAR PASCAL XDbSetGetPrev( HANDLE, LPSTR, LPSTR, LPVOID, short);
  57.  
  58. /* Error defines */
  59. #define E_TESTDRIVE     -5
  60. #define E_WINALLOC      -4
  61. #define E_LOADMODULE    -3
  62. #define E_INVALIDCASE   -2
  63. #define E_DOS           -1
  64. #define E_NORECNAME     1
  65. #define E_NOFLDNAME     2
  66. #define E_INVALIDSET    3
  67. #define E_NOTAKEY       4
  68. #define E_NOTFOUND      5
  69. #define E_NEXTGUESS     6
  70. #define E_NOCURRENT     7 
  71. #define E_NONEXT        8 
  72. #define E_NOPREV        9 
  73. #define E_NOMEMBER      10
  74. #define E_NOOWNER       11
  75. #define E_ALREADYOPEN   12
  76.  
  77.  
  78. /************************************************
  79.  * CDB Internals
  80.  ************************************************/
  81.  
  82. /* DBCALL.C prototypes */
  83. DWORD DbCall( HANDLE, WORD, ...);
  84. DWORD XDbCall( HANDLE, WORD, ...);
  85.  
  86. /* CDB Server Name */
  87. #define CDB_SERVER          "dbserver.exe"
  88. #define CDB_SERVER_CLASS    "CDBServerClass"
  89.  
  90. /* Structure passed between client and server */
  91. typedef struct sCDBTALK
  92.     {
  93.     WORD    wCall;
  94.     char    szName1[67];
  95.     char    szName2[32];
  96.     HANDLE  hData1;
  97.     HANDLE  hData2;
  98.     } CDBTALK;
  99.  
  100. /* Type definitions */
  101. typedef char            CHAR;
  102. typedef unsigned char   UCHAR;
  103. typedef short           INT;
  104. typedef unsigned short  UINT;
  105. typedef unsigned long   ULONG;
  106.  
  107. /* DBMGR.C prototype */
  108. INT cdb( INT, ...);
  109.  
  110. /* Database call defines */
  111. #define D_OPEN                  0
  112. #define D_CLOSE                 1
  113. #define D_FLUSH                 2
  114. #define D_GET_CURRENCY          3
  115. #define D_UPDATE_CURRENCY       4
  116. #define D_FIND_FIRST_RECORD     5
  117. #define D_FIND_LAST_RECORD      6
  118. #define D_FIND_NEXT_RECORD      7
  119. #define D_FIND_PREV_RECORD      8
  120. #define D_FIND_RECORD_BY_KEY    9
  121. #define D_GET_FIRST_RECORD      10
  122. #define D_GET_LAST_RECORD       11
  123. #define D_GET_NEXT_RECORD       12
  124. #define D_GET_PREV_RECORD       13
  125. #define D_GET_RECORD_BY_KEY     14
  126. #define D_GET_CURRENT_RECORD    15
  127. #define D_ADD_RECORD            16
  128. #define D_UPDATE_RECORD         17
  129. #define D_DELETE_RECORD         18
  130. #define D_FIND_FIRST_SET        19
  131. #define D_FIND_LAST_SET         20
  132. #define D_FIND_NEXT_SET         21
  133. #define D_FIND_PREV_SET         22
  134. #define D_GET_FIRST_SET         23
  135. #define D_GET_LAST_SET          24
  136. #define D_GET_NEXT_SET          25
  137. #define D_GET_PREV_SET          26
  138. #define D_GET_SET_OWNER         27
  139. #define D_ADD_SET               28
  140. #define D_DELETE_SET            29
  141.  
  142. #define NBRHANDLES      8       /* Maximum number of file handles       */
  143. #define MAXKEY          8       /* Maximum # of keys per key record     */
  144. #define KEYPAGESIZE     512     /* Key page buffer size                 */
  145. #define NBRPAGES        16      /* Number of key page buffers           */
  146. #define DATAPAGESIZE    2048    /* Data page buffer size                */
  147. #define DATASLOTSIZE    1024    /* Data file slot buffer size           */
  148.  
  149. /* Testdrive version defines */
  150. #define TESTDRIVE_MAX_RECORDS   50L
  151.  
  152. /* Field index structure defines */
  153. #define KEY_FIELD       0x01
  154. #define SET_KEY_FIELD   0x01
  155.  
  156. /* Handle index structure defines */
  157. #define FILE_MODIFIED   0x01
  158.  
  159. /* Key file index structure defines */
  160. #define PAGE_FULL       0x01
  161.  
  162. /* Page index structure defines */
  163. #define PAGE_DIRTY      0x01
  164.  
  165. /* DataBase structures and unions */
  166. union  type
  167.     {
  168.     CHAR                charval;
  169.     INT                 intval;
  170.     LONG                longval;
  171.     float               floatval;
  172.     double              doubleval;
  173.     CHAR                *ptrval;
  174.     UCHAR               ucharval;
  175.     UINT                uintval;
  176.     ULONG               ulongval;
  177.     };
  178.  
  179. struct dbheader                         /* 128 bytes                    */
  180.     {               
  181.     CHAR                title[96];      /* DBD title                    */
  182.     UINT                totrecs;        /* Total number of records      */
  183.     UINT                totowns;        /* Total number of owners       */
  184.     UINT                totmems;        /* Total number of members      */
  185.     UINT                totflds;        /* Total number of fields       */
  186.     CHAR                prefix[6];      /* File prefix description      */
  187.     CHAR                filler[18];
  188.     };
  189.  
  190. struct record_index                     /* 46 bytes                     */
  191.     {
  192.     UINT                firstown;       /* First owner                  */
  193.     UINT                nbrowns;        /* Number of owners             */
  194.     UINT                firstmem;       /* First member                 */
  195.     UINT                nbrmems;        /* Number of members            */
  196.     UINT                firstfld;       /* First field                  */
  197.     UINT                nbrflds;        /* Number of fields             */
  198.     UINT                reclen;         /* Record length                */
  199.     CHAR                recname[32];    /* Record name                  */
  200.     };
  201.  
  202. struct owner_index                      /* 4 bytes                      */
  203.     {
  204.     UINT                nextown;        /* Next owner                   */
  205.     UINT                ownnum;         /* Owner record number          */
  206.     };
  207.  
  208. struct member_index                     /* 8 bytes                      */
  209.     {
  210.     UINT                nextmem;        /* Next member                  */
  211.     UINT                memnum;         /* Member record number         */
  212.     UINT                memkeyfld;      /* Key field number for set     */
  213.     UINT                memflags;       /* Bit 0 - key field present    */
  214.     };
  215.  
  216. struct field_index                      /* 40 bytes                     */
  217.     {
  218.     UCHAR               fldtype;        /* Field type  Bit 0 - char     */
  219.                                         /*             Bit 1 - int      */
  220.                                         /*             Bit 2 - short    */
  221.                                         /*             Bit 3 - long     */
  222.                                         /*             Bit 4 - float    */
  223.                                         /*             Bit 5 - double   */
  224.                                         /*             Bit 7 - unsigned */
  225.     UINT                fldlen;         /* Field length                 */
  226.     UINT                flddim;         /* Field dimension              */
  227.     CHAR                fldname[32];    /* Field name                   */
  228.     UINT                fldkey;         /* Key number of data struct    */
  229.     UCHAR               fldflags;       /* Bit 0 - key field            */
  230.     };
  231.  
  232. /* Field casting defines */
  233. #define FLDTYPE_CHAR            0x01
  234. #define FLDTYPE_INT             0x02
  235. #define FLDTYPE_SHORT           0x04
  236. #define FLDTYPE_LONG            0x08
  237. #define FLDTYPE_FLOAT           0x10
  238. #define FLDTYPE_DOUBLE          0x20
  239. #define FLDTYPE_UNSIGNED        0x80
  240.  
  241. struct  key_file_index                  /* 32 bytes                     */
  242.     {
  243.     CHAR        name[12];               /* Key file name                */
  244.     UINT        nextavailpage;          /* Next available page          */
  245.     UINT        firstdelpage;           /* First page in the delete     */
  246.                                         /* chain.                       */
  247.     UINT        pagenbr[MAXKEY];        /* Key 1st page index           */
  248.     };
  249.  
  250. struct  key_page_index                  /* 10 bytes                     */
  251.     {
  252.     UINT        prevpage;               /* Previous page in sort tree   */
  253.     UINT        nextpage;               /* Next page in sort tree       */
  254.     UINT        slotsused;              /* Number of slots used on page */
  255.     UINT        slotsize;               /* Size of key slot             */
  256.     UINT        flags;                  /* Bit 0 - page is full         */
  257.     };
  258.  
  259. struct  data_file_index                 /* 32 bytes                     */
  260.     {
  261.     CHAR        name[12];               /* Data file name               */
  262.     ULONG       nextavailslot;          /* Next available slot          */
  263.     ULONG       firstdelslot;           /* First slot in the delete     */
  264.                                         /* chain.                       */
  265.     UINT        slotsize;               /* Size of data slot            */
  266.     CHAR        filler[10];
  267.     };
  268.  
  269. struct  data_slot_index                 /* 6 bytes                      */
  270.     {
  271.     UINT        offsettodata;           /* Offset to actual data        */
  272.     ULONG       nextdel;                /* DBA of next member in the    */
  273.                                         /* delete chain.                */
  274.     };
  275.  
  276. struct  ownptr_index                    /* 8 bytes                      */
  277.     {
  278.     ULONG       firstmem;               /* Dba of first member          */
  279.     ULONG       lastmem;                /* Dba of last member           */
  280.     };
  281.  
  282. struct  memptr_index                    /* 12 bytes                     */
  283.     {
  284.     ULONG       owndba;                 /* Dba of owner record          */
  285.     ULONG       prevmem;                /* Dba of prev member in chain  */
  286.     ULONG       nextmem;                /* Dba of next member in chain  */
  287.     };
  288.  
  289. struct handle_index                     /* 4 bytes                      */
  290.     {
  291.     INT         handle;                 /* Handle number                */
  292.     UINT        flags;                  /* Bit 0 - set if modified      */
  293.     };
  294.  
  295. struct page_index                       /* 520 bytes                    */
  296.     {
  297.     UINT        recnbr;                 /* Record number                */
  298.     UINT        fldnbr;                 /* Field number                 */
  299.     UINT        diskpagenbr;            /* Page number                  */
  300.     CHAR        buffer[KEYPAGESIZE];    /* Data buffer                  */
  301.     UINT        flags;                  /* Bit 0 - set if page is dirty */
  302.     };
  303.  
  304. struct currency_index                   /* 36 bytes                     */
  305.     {
  306.     struct 
  307.         {
  308.         UINT    page;
  309.         UINT    slot;
  310.         } keydba[MAXKEY];               /* Array of key dba's           */
  311.     ULONG       datadba;                /* Data database address        */
  312.     };
  313.